home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet internetowy / Przegladarki internetowe / Mozilla Seamonkey 1.0.5 pl / seamonkey-1.0.5.pl-PL.win32.installer.exe / VENKMAN.XPI / bin / chrome / venkman.jar / content / venkman / menu-manager.js < prev    next >
Encoding:
JavaScript  |  2004-04-18  |  16.0 KB  |  507 lines
  1. /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  2.  *
  3.  * ***** BEGIN LICENSE BLOCK *****
  4.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  5.  *
  6.  * The contents of this file are subject to the Mozilla Public License Version
  7.  * 1.1 (the "License"); you may not use this file except in compliance with
  8.  * the License. You may obtain a copy of the License at
  9.  * http://www.mozilla.org/MPL/
  10.  *
  11.  * Software distributed under the License is distributed on an "AS IS" basis,
  12.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13.  * for the specific language governing rights and limitations under the
  14.  * License.
  15.  *
  16.  * The Original Code is The JavaScript Debugger.
  17.  *
  18.  * The Initial Developer of the Original Code is
  19.  * Netscape Communications Corporation.
  20.  * Portions created by the Initial Developer are Copyright (C) 1998
  21.  * the Initial Developer. All Rights Reserved.
  22.  *
  23.  * Contributor(s):
  24.  *   Robert Ginda, <rginda@netscape.com>, original author
  25.  *
  26.  * Alternatively, the contents of this file may be used under the terms of
  27.  * either the GNU General Public License Version 2 or later (the "GPL"), or
  28.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  29.  * in which case the provisions of the GPL or the LGPL are applicable instead
  30.  * of those above. If you wish to allow use of your version of this file only
  31.  * under the terms of either the GPL or the LGPL, and not to allow others to
  32.  * use your version of this file under the terms of the MPL, indicate your
  33.  * decision by deleting the provisions above and replace them with the notice
  34.  * and other provisions required by the GPL or the LGPL. If you do not delete
  35.  * the provisions above, a recipient may use your version of this file under
  36.  * the terms of any one of the MPL, the GPL or the LGPL.
  37.  *
  38.  * ***** END LICENSE BLOCK ***** */
  39.  
  40. function MenuManager (commandManager, menuSpecs, contextFunction, commandStr)
  41. {
  42.     var menuManager = this;
  43.  
  44.     this.commandManager = commandManager;
  45.     this.menuSpecs = menuSpecs;
  46.     this.contextFunction = contextFunction;
  47.     this.commandStr = commandStr;
  48.  
  49.     this.onPopupShowing =
  50.         function mmgr_onshow (event) { return menuManager.showPopup (event); };
  51.     this.onPopupHiding =
  52.         function mmgr_onhide (event) { return menuManager.hidePopup (event); };
  53. }
  54.  
  55. /**
  56.  * Internal use only.
  57.  *
  58.  * Registers event handlers on a given menu.
  59.  */
  60. MenuManager.prototype.hookPopup =
  61. function mmgr_hookpop (node)
  62. {
  63.     node.addEventListener ("popupshowing", this.onPopupShowing, false);
  64.     node.addEventListener ("popuphiding",  this.onPopupHiding, false);
  65. }
  66.  
  67. /**
  68.  * Internal use only.
  69.  *
  70.  * |showPopup| is called from the "onpopupshowing" event of menus
  71.  * managed by the CommandManager.  If a command is disabled, represents a command
  72.  * that cannot be "satisfied" by the current command context |cx|, or has an
  73.  * "enabledif" attribute that eval()s to false, then the menuitem is disabled.
  74.  * In addition "checkedif" and "visibleif" attributes are eval()d and
  75.  * acted upon accordingly.
  76.  */
  77. MenuManager.prototype.showPopup =
  78. function mmgr_showpop (event)
  79. {
  80.     //dd ("showPopup {");
  81.     /* returns true if the command context has the properties required to
  82.      * execute the command associated with |menuitem|.
  83.      */
  84.     function satisfied()
  85.     {
  86.         if (menuitem.hasAttribute("isSeparator") || 
  87.             !menuitem.hasAttribute("commandname"))
  88.         {
  89.             return true;
  90.         }
  91.  
  92.         if (!("menuManager" in cx))
  93.         {
  94.             dd ("no menuManager in cx");
  95.             return false;
  96.         }
  97.         
  98.         var name = menuitem.getAttribute("commandname");
  99.         var commandManager = cx.menuManager.commandManager;
  100.         var commands = commandManager.commands;
  101.  
  102.         if (!ASSERT (name in commands,
  103.                      "menu contains unknown command '" + name + "'"))
  104.         {
  105.             return false;
  106.         }
  107.  
  108.         var rv = commandManager.isCommandSatisfied(cx, commands[name]);
  109.         delete cx.parseError;
  110.         return rv;
  111.     };
  112.     
  113.     /* Convenience function for "enabledif", etc, attributes. */
  114.     function has (prop)
  115.     {
  116.         return (prop in cx);
  117.     };
  118.     
  119.     /* evals the attribute named |attr| on the node |node|. */
  120.     function evalIfAttribute (node, attr)
  121.     {
  122.         var ex;
  123.         var expr = node.getAttribute(attr);
  124.         if (!expr)
  125.             return true;
  126.         
  127.         expr = expr.replace (/\Wand\W/gi, " && ");
  128.  
  129.         try
  130.         {
  131.             return eval("(" + expr + ")");
  132.         }
  133.         catch (ex)
  134.         {
  135.             dd ("caught exception evaling '" + node.getAttribute("id") + "'.'" +
  136.                 attr + "'\n" + ex);
  137.         }
  138.         return true;
  139.     };
  140.     
  141.     var cx;
  142.     var popup = event.originalTarget;
  143.     var menuitem = popup.firstChild;
  144.  
  145.     
  146.     /* If the host provided a |contextFunction|, use it now.  Remember the
  147.      * return result as this.cx for use if something from this menu is actually
  148.      * dispatched.  this.cx is deleted in |hidePopup|. */
  149.     if (typeof this.contextFunction == "function")
  150.     {
  151.         cx = this.cx = this.contextFunction (popup.getAttribute("menuName"),
  152.                                              event);
  153.     }
  154.     else
  155.     {
  156.         cx = this.cx = { menuManager: this, originalEvent: event };
  157.     }
  158.  
  159.     do
  160.     {
  161.         /* should it be visible? */
  162.         if (menuitem.hasAttribute("visibleif"))
  163.         {
  164.             if (evalIfAttribute(menuitem, "visibleif"))
  165.                 menuitem.removeAttribute ("hidden");
  166.             else
  167.             {
  168.                 menuitem.setAttribute ("hidden", "true");
  169.                 continue;
  170.             }
  171.         }
  172.         
  173.         /* ok, it's visible, maybe it should be disabled? */
  174.         if (satisfied())
  175.         {
  176.             if (menuitem.hasAttribute("enabledif"))
  177.             {
  178.                 if (evalIfAttribute(menuitem, "enabledif"))
  179.                     menuitem.removeAttribute ("disabled");
  180.                 else
  181.                     menuitem.setAttribute ("disabled", "true");
  182.             }
  183.             else
  184.                 menuitem.removeAttribute ("disabled");
  185.         }
  186.         else
  187.         {
  188.             menuitem.setAttribute ("disabled", "true");
  189.         }
  190.         
  191.         /* should it have a check? */
  192.         if (menuitem.hasAttribute("checkedif"))
  193.         {
  194.             if (evalIfAttribute(menuitem, "checkedif"))
  195.                 menuitem.setAttribute ("checked", "true");
  196.             else
  197.                 menuitem.removeAttribute ("checked");
  198.         }
  199.         
  200.     } while ((menuitem = menuitem.nextSibling));
  201.  
  202.     //dd ("}");
  203.     
  204.     return true;
  205. }
  206.  
  207. /**
  208.  * Internal use only.
  209.  *
  210.  * |hidePopup| is called from the "onpopuphiding" event of menus
  211.  * managed by the CommandManager.  Nothing to do here anymore.
  212.  * We used to just clean up this.cx, but that's a problem for nested
  213.  * menus.
  214.  */
  215. MenuManager.prototype.hidePopup =
  216. function mmgr_hidepop (id)
  217. {
  218.     return true;
  219. }
  220.  
  221. /**
  222.  * Appends a sub-menu to an existing menu.
  223.  * @param parentNode  DOM Node to insert into
  224.  * @param beforeNode  DOM Node already contained by parentNode, to insert before
  225.  * @param id      ID of the sub-menu to add.
  226.  * @param label   Text to use for this sub-menu.  The & character can be
  227.  *                used to indicate the accesskey.
  228.  * @param attribs Object containing CSS attributes to set on the element.
  229.  */
  230. MenuManager.prototype.appendSubMenu =
  231. function mmgr_addsmenu (parentNode, beforeNode, menuName, domId, label, attribs)
  232. {
  233.     var document = parentNode.ownerDocument;
  234.     
  235.     /* sometimes the menu is already there, for overlay purposes. */
  236.     var menu = document.getElementById(domId);
  237.     
  238.     if (!menu)
  239.     {
  240.         menu = document.createElement ("menu");
  241.         menu.setAttribute ("id", domId);
  242.         parentNode.insertBefore(menu, beforeNode);
  243.     }
  244.  
  245.     var menupopup = menu.firstChild;
  246.     
  247.     if (!menupopup)
  248.     {
  249.         menupopup = document.createElement ("menupopup");
  250.         menupopup.setAttribute ("id", domId + "-popup");
  251.         menu.appendChild(menupopup);    
  252.         menupopup = menu.firstChild;
  253.     }
  254.  
  255.     menupopup.setAttribute ("menuName", menuName);
  256.  
  257.     menu.setAttribute ("accesskey", getAccessKey(label));
  258.     menu.setAttribute ("label", label.replace("&", ""));
  259.     menu.setAttribute ("isSeparator", true);
  260.  
  261.     if (typeof attribs == "object")
  262.     {
  263.         for (var p in attribs)
  264.             menu.setAttribute (p, attribs[p]);
  265.     }
  266.  
  267.     this.hookPopup (menupopup);
  268.  
  269.     return menupopup;
  270. }
  271.  
  272. /**
  273.  * Appends a popup to an existing popupset.
  274.  * @param parentNode  DOM Node to insert into
  275.  * @param beforeNode  DOM Node already contained by parentNode, to insert before
  276.  * @param id      ID of the popup to add.
  277.  * @param label   Text to use for this popup.  Popup menus don't normally have
  278.  *                labels, but we set a "label" attribute anyway, in case
  279.  *                the host wants it for some reason.  Any "&" characters will
  280.  *                be stripped.
  281.  * @param attribs Object containing CSS attributes to set on the element.
  282.  */
  283. MenuManager.prototype.appendPopupMenu =
  284. function mmgr_addpmenu (parentNode, beforeNode, menuName, id, label, attribs)
  285. {
  286.     var document = parentNode.ownerDocument;
  287.     var popup = document.createElement ("popup");
  288.     popup.setAttribute ("id", id);
  289.     if (label)
  290.         popup.setAttribute ("label", label.replace("&", ""));
  291.     if (typeof attribs == "object")
  292.     {
  293.         for (var p in attribs)
  294.             popup.setAttribute (p, attribs[p]);
  295.     }
  296.  
  297.     popup.setAttribute ("menuName", menuName);
  298.  
  299.     parentNode.insertBefore(popup, beforeNode);
  300.     this.hookPopup (popup);
  301.  
  302.     return popup;
  303. }
  304.  
  305. /**
  306.  * Appends a menuitem to an existing menu or popup.
  307.  * @param parentNode  DOM Node to insert into
  308.  * @param beforeNode  DOM Node already contained by parentNode, to insert before
  309.  * @param command A reference to the CommandRecord this menu item will represent.
  310.  * @param attribs Object containing CSS attributes to set on the element.
  311.  */
  312. MenuManager.prototype.appendMenuItem =
  313. function mmgr_addmenu (parentNode, beforeNode, commandName, attribs)
  314. {
  315.     var menuManager = this;    
  316.     
  317.     var document = parentNode.ownerDocument;
  318.     if (commandName == "-")
  319.         return this.appendMenuSeparator(parentNode, beforeNode, attribs);
  320.     
  321.     var parentId = parentNode.getAttribute("id");
  322.     
  323.     if (!ASSERT(commandName in this.commandManager.commands,
  324.                 "unknown command " + commandName + " targeted for " +
  325.                 parentId))
  326.     {
  327.         return null;
  328.     }
  329.  
  330.     var command = this.commandManager.commands[commandName];
  331.     var menuitem = document.createElement ("menuitem");
  332.     menuitem.setAttribute ("id", parentId + ":" + commandName);
  333.     menuitem.setAttribute ("commandname", command.name);
  334.     menuitem.setAttribute ("key", "key:" + command.name);
  335.     menuitem.setAttribute ("accesskey", getAccessKey(command.label));
  336.     menuitem.setAttribute ("label", command.label.replace("&", ""));
  337.     menuitem.setAttribute ("oncommand", this.commandStr);
  338.  
  339.     if (typeof attribs == "object")
  340.     {
  341.         for (var p in attribs)
  342.             menuitem.setAttribute (p, attribs[p]);
  343.     }
  344.     
  345.     command.uiElements.push(menuitem);
  346.     parentNode.insertBefore (menuitem, beforeNode);
  347.  
  348.     return menuitem;
  349. }
  350.  
  351. /**
  352.  * Appends a menuseparator to an existing menu or popup.
  353.  * @param parentNode  DOM Node to insert into
  354.  * @param beforeNode  DOM Node already contained by parentNode, to insert before
  355.  * @param attribs Object containing CSS attributes to set on the element.
  356.  */
  357. MenuManager.prototype.appendMenuSeparator =
  358. function mmgr_addsep (parentNode, beforeNode, attribs)
  359. {
  360.     var document = parentNode.ownerDocument;
  361.     var menuitem = document.createElement ("menuseparator");
  362.     menuitem.setAttribute ("isSeparator", true);
  363.     if (typeof attribs == "object")
  364.     {
  365.         for (var p in attribs)
  366.             menuitem.setAttribute (p, attribs[p]);
  367.     }
  368.     parentNode.insertBefore (menuitem, beforeNode);
  369.  
  370.     return menuitem;
  371. }
  372.  
  373. /**
  374.  * Appends a toolbaritem to an existing box element.
  375.  * @param parentNode  DOM Node to insert into
  376.  * @param beforeNode  DOM Node already contained by parentNode, to insert before
  377.  * @param command A reference to the CommandRecord this toolbaritem will
  378.  *                represent.
  379.  * @param attribs Object containing CSS attributes to set on the element.
  380.  */
  381. MenuManager.prototype.appendToolbarItem =
  382. function mmgr_addtb (parentNode, beforeNode, commandName, attribs)
  383. {
  384.     if (commandName == "-")
  385.         return this.appendToolbarSeparator(parentNode, beforeNode, attribs);
  386.  
  387.     var parentId = parentNode.getAttribute("id");
  388.     
  389.     if (!ASSERT(commandName in this.commandManager.commands,
  390.                 "unknown command " + commandName + " targeted for " +
  391.                 parentId))
  392.     {
  393.         return null;
  394.     }
  395.     
  396.     var command = this.commandManager.commands[commandName];
  397.     var document = parentNode.ownerDocument;    
  398.     var tbitem = document.createElement ("toolbarbutton");
  399.  
  400.     var id = parentNode.getAttribute("id") + ":" + commandName;
  401.     tbitem.setAttribute ("id", id);
  402.     tbitem.setAttribute ("class", "toolbarbutton-1");
  403.     if (command.tip)
  404.         tbitem.setAttribute ("tooltiptext", command.tip);
  405.     tbitem.setAttribute ("label", command.label.replace("&", ""));
  406.     tbitem.setAttribute ("oncommand",
  407.                          "dispatch('" + commandName + "');");
  408.     if (typeof attribs == "object")
  409.     {
  410.         for (var p in attribs)
  411.             tbitem.setAttribute (p, attribs[p]);
  412.     }
  413.     
  414.     command.uiElements.push(tbitem);
  415.     parentNode.insertBefore (tbitem, beforeNode);
  416.  
  417.     return tbitem;
  418. }
  419.  
  420. /**
  421.  * Appends a toolbarseparator to an existing box.
  422.  * @param parentNode  DOM Node to insert into
  423.  * @param beforeNode  DOM Node already contained by parentNode, to insert before
  424.  * @param attribs Object containing CSS attributes to set on the element.
  425.  */
  426. MenuManager.prototype.appendToolbarSeparator =
  427. function mmgr_addmenu (parentNode, beforeNode, attribs)
  428. {
  429.     var document = parentNode.ownerDocument;    
  430.     var tbitem = document.createElement ("toolbarseparator");
  431.     tbitem.setAttribute ("isSeparator", true);
  432.     if (typeof attribs == "object")
  433.     {
  434.         for (var p in attribs)
  435.             tbitem.setAttribute (p, attribs[p]);
  436.     }
  437.     parentNode.appendChild (tbitem);
  438.  
  439.     return tbitem;
  440. }
  441.  
  442. /**
  443.  * Creates menu DOM nodes from a menu specification.
  444.  * @param parentNode  DOM Node to insert into
  445.  * @param beforeNode  DOM Node already contained by parentNode, to insert before
  446.  * @param menuSpec    array of menu items
  447.  */
  448. MenuManager.prototype.createMenu =
  449. function mmgr_newmenu (parentNode, beforeNode, menuName, domId, attribs)
  450. {
  451.     if (typeof domId == "undefined")
  452.         domId = menuName;
  453.     
  454.     if (!ASSERT(menuName in this.menuSpecs, "unknown menu name " + menuName))
  455.         return null;
  456.  
  457.     var menuSpec = this.menuSpecs[menuName];
  458.     
  459.     var subMenu = this.appendSubMenu (parentNode, beforeNode, menuName, domId,
  460.                                       menuSpec.label, attribs);
  461.  
  462.     this.createMenuItems (subMenu, null, menuSpec.items);
  463.     return subMenu;
  464. }
  465.  
  466. MenuManager.prototype.createMenuItems =
  467. function mmgr_newitems (parentNode, beforeNode, menuItems)
  468. {
  469.     function itemAttribs()
  470.     {
  471.         return (1 in menuItems[i]) ? menuItems[i][1] : null;
  472.     };
  473.  
  474.     var parentId = parentNode.getAttribute("id");
  475.     
  476.     for (var i in menuItems)
  477.     {
  478.         var itemName = menuItems[i][0];
  479.         if (itemName[0] == ">")
  480.         {
  481.             itemName = itemName.substr(1);
  482.             if (!ASSERT(itemName in this.menuSpecs,
  483.                         "unknown submenu " + itemName + " referenced in " +
  484.                         parentId))
  485.             {
  486.                 continue;
  487.             }
  488.             this.createMenu (parentNode, beforeNode, itemName,
  489.                              parentId + ":" + itemName, itemAttribs());
  490.         }
  491.         else if (itemName in this.commandManager.commands)
  492.         {
  493.             this.appendMenuItem (parentNode, beforeNode, itemName,
  494.                                  itemAttribs());
  495.         }
  496.         else if (itemName == "-")
  497.         {
  498.             this.appendMenuSeparator (parentNode, beforeNode, itemAttribs());
  499.         }
  500.         else
  501.         {
  502.             dd ("unknown command " + itemName + " referenced in " + parentId);
  503.         }
  504.     }
  505.         
  506. }
  507.